/**
 * 请求验证中间件
 * @module middlewares/validation
 */

const { body, validationResult } = require('express-validator');

/**
 * 验证注册请求
 */
exports.validateRegister = [
  // 用户名验证
  body('username')
    .notEmpty().withMessage('用户名不能为空')
    .isLength({ min: 3, max: 20 }).withMessage('用户名长度应在3-20个字符之间')
    .matches(/^[a-zA-Z0-9_]+$/).withMessage('用户名只能包含字母、数字和下划线'),
  
  // 邮箱验证
  body('email')
    .notEmpty().withMessage('邮箱不能为空')
    .isEmail().withMessage('邮箱格式不正确'),
  
  // 密码验证
  body('password')
    .notEmpty().withMessage('密码不能为空')
    .isLength({ min: 6 }).withMessage('密码长度至少为6个字符')
    .matches(/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d@$!%*#?&]{6,}$/)
    .withMessage('密码必须包含至少一个字母和一个数字'),
  
  // 处理验证结果
  (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        code: 400,
        message: '参数验证失败',
        errors: errors.array().map(err => ({
          field: err.param,
          message: err.msg
        }))
      });
    }
    next();
  }
];

/**
 * 验证登录请求
 */
exports.validateLogin = [
  // 用户名验证
  body('username')
    .notEmpty().withMessage('用户名不能为空'),
  
  // 密码验证
  body('password')
    .notEmpty().withMessage('密码不能为空'),
  
  // 处理验证结果
  (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        code: 400,
        message: '参数验证失败',
        errors: errors.array().map(err => ({
          field: err.param,
          message: err.msg
        }))
      });
    }
    next();
  }
];

/**
 * 验证刷新令牌请求
 */
exports.validateRefreshToken = [
  // 刷新令牌验证
  body('refreshToken')
    .notEmpty().withMessage('刷新令牌不能为空'),
  
  // 处理验证结果
  (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        code: 400,
        message: '参数验证失败',
        errors: errors.array().map(err => ({
          field: err.param,
          message: err.msg
        }))
      });
    }
    next();
  }
];

/**
 * 验证更新用户信息请求
 */
exports.validateUpdateProfile = [
  // 邮箱验证（可选）
  body('email')
    .optional()
    .isEmail().withMessage('邮箱格式不正确'),
  
  // 密码验证（可选）
  body('password')
    .optional()
    .isLength({ min: 6 }).withMessage('密码长度至少为6个字符')
    .matches(/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d@$!%*#?&]{6,}$/)
    .withMessage('密码必须包含至少一个字母和一个数字'),
  
  // 当前密码验证（当更新密码时必须）
  body('currentPassword')
    .if(body('password').exists())
    .notEmpty().withMessage('更新密码时必须提供当前密码'),
  
  // 处理验证结果
  (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        code: 400,
        message: '参数验证失败',
        errors: errors.array().map(err => ({
          field: err.param,
          message: err.msg
        }))
      });
    }
    next();
  }
];

/**
 * 验证升级会员请求
 */
exports.validateUpgrade = [
  // 会员计划ID验证
  body('planId')
    .notEmpty().withMessage('会员计划ID不能为空'),
  
  // 支付方式验证
  body('paymentMethod')
    .notEmpty().withMessage('支付方式不能为空')
    .isIn(['alipay', 'wechat', 'paypal', 'credit_card']).withMessage('无效的支付方式'),
  
  // 订单ID验证
  body('orderId')
    .notEmpty().withMessage('订单ID不能为空'),
  
  // 处理验证结果
  (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        code: 400,
        message: '参数验证失败',
        errors: errors.array().map(err => ({
          field: err.param,
          message: err.msg
        }))
      });
    }
    next();
  }
];

/**
 * 验证会员计划请求
 */
exports.validatePlan = [
  // 计划ID验证
  body('id')
    .notEmpty().withMessage('计划ID不能为空'),
  
  // 计划名称验证
  body('name')
    .notEmpty().withMessage('计划名称不能为空')
    .isLength({ min: 2, max: 30 }).withMessage('计划名称长度应在2-30个字符之间'),
  
  // 价格验证
  body('price')
    .notEmpty().withMessage('价格不能为空')
    .isNumeric().withMessage('价格必须是数字'),
  
  // 货币验证
  body('currency')
    .notEmpty().withMessage('货币不能为空')
    .isIn(['CNY', 'USD', 'EUR']).withMessage('不支持的货币类型'),
  
  // 周期验证
  body('billingCycle')
    .notEmpty().withMessage('计费周期不能为空')
    .isIn(['monthly', 'quarterly', 'annually']).withMessage('无效的计费周期'),
  
  // 功能特性验证
  body('features')
    .isArray().withMessage('功能特性必须是数组'),
  
  // 使用限制验证
  body('limits')
    .isObject().withMessage('使用限制必须是对象'),
  
  // 处理验证结果
  (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        code: 400,
        message: '参数验证失败',
        errors: errors.array().map(err => ({
          field: err.param,
          message: err.msg
        }))
      });
    }
    next();
  }
];

/**
 * 验证统计记录请求
 */
exports.validateStatsRecord = [
  // 工具类型验证
  body('toolType')
    .notEmpty().withMessage('工具类型不能为空')
    .isIn(['image', 'text', 'audio', 'video', 'other']).withMessage('无效的工具类型'),
  
  // 操作类型验证
  body('operationType')
    .notEmpty().withMessage('操作类型不能为空'),
  
  // 元数据验证（可选）
  body('metadata')
    .optional()
    .isObject().withMessage('元数据必须是对象'),
  
  // 处理验证结果
  (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        code: 400,
        message: '参数验证失败',
        errors: errors.array().map(err => ({
          field: err.param,
          message: err.msg
        }))
      });
    }
    next();
  }
]; 